C:/Projekte/RAIS/common/Field.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Data;
using System.Text;
using FieldTypes = System.Collections.Generic.Dictionary<string, RAIS.Common.TableManagement.Field.FieldTypeData>;
using FieldSizes = System.Collections.Generic.Dictionary<string, RAIS.Common.TableManagement.Field.FieldSizeData>;
using NecessityTypes = System.Collections.Generic.Dictionary<string, RAIS.Common.TableManagement.Field.NecessityTypeData>;

namespace RAIS.Common.TableManagement
{
        public class Field : DBObject
        {
                //*********************************************************************
                #region Enumerators
                public enum FieldType
                {
                        Text = 0,
                        Date,
                        Numeric,
                        SingleLookup,
                        MultipleLookup,
                        LookupPlusIntegerValue,
                        LookupPlusScientificValue,
                        Link,
                        Logical,
                        Label
                }
                public enum NecessityType
                {
                        Required = 0,
                        Suggested,
                        NotRequired
                }
                public enum FieldSize
                { 
                        Large = 0,
                        Medium,
                        Memo,
                        Small,
                        Integer,
                        Rational,
                        Scientific,
                        TimeInterval,
                        Year
                }
                #endregion
                //*********************************************************************
                #region Fields
                static FieldTypes fieldTypesDictionary;
                static FieldSizes fieldSizesDictionary;
                static NecessityTypes necessityTypesDictionary;

                Table table;
                string localLanguageFieldName = "";
                string fieldPurpose = "";
                string localLanguageFieldPurpose = "";
                FieldType fieldType;
                FieldSize? fieldSize;
                NecessityType necessityType;
                int order;
                bool isNameField = false;
                bool systemField = false;
        bool lockedField = false;

                bool visibleOnForms = true;
                bool uniqueValue;
                bool needsTranslation = false;
                bool multiline;
                bool highField = false;
                bool readOnly = false;
                Table relatedTable;
                string queryName;
                int? parentFieldID = null;
                #endregion
                //*********************************************************************
                #region Properties
                static public FieldTypes FieldTypesDictionary
                {
                        get { return fieldTypesDictionary; }
                        set { fieldTypesDictionary = value; }
                }
                static public FieldSizes FieldSizesDictionary
                {
                        get { return fieldSizesDictionary; }
                        set { fieldSizesDictionary = value; }
                }
                static public NecessityTypes NecessityTypesDictionary
                {
                        get { return necessityTypesDictionary; }
                        set { necessityTypesDictionary = value; }
                }

                public Table Table
                {
                        get { return this.table; }
                        set { this.table = value; }
                }
                public string LocalLanguageFieldName
                {
                        get { return this.localLanguageFieldName; }
                        set { localLanguageFieldName = value; }
                }
                public string FieldPurpose
                {
                        get { return this.fieldPurpose; }
                        set { fieldPurpose = value; }
                }
                public string LocalLanguageFieldPurpose
                {
                        get { return this.localLanguageFieldPurpose; }
                        set { localLanguageFieldPurpose = value; }
                }
                public FieldType Type
                {
                        get { return this.fieldType; }
                }
                public FieldTypeData TypeData
                {
                        get { return fieldTypesDictionary[this.TypeText]; }
                }
                public string TypeText
                {
                        get
                        {
                                string result = "";
                                foreach (KeyValuePair<string, FieldTypeData> fieldTypeItem in fieldTypesDictionary)
                                        if (fieldTypeItem.Value.Type == this.fieldType)
                                        {
                                                result = fieldTypeItem.Value.VisibleName;
                                                break;
                                        }
                                return result;
                        }
                        set 
            { 
                this.fieldType = fieldTypesDictionary[value].Type;
                this.fieldSize = null;
            }
                }
                public FieldSize? Size
                {
                        get { return this.fieldSize; }
                }
                public FieldSizeData SizeData
                {
                        get { return (this.fieldSize == null) ? null : fieldSizesDictionary[this.SizeText]; }
                }
                public string SizeText
                {
                        get
                        {
                                string result = "";
                                foreach (KeyValuePair<string, FieldSizeData> fieldSizeItem in fieldSizesDictionary)
                                        if (fieldSizeItem.Value.Type == this.fieldSize)
                                        {
                                                result = fieldSizeItem.Value.VisibleName;
                                                break;
                                        }
                                return result;
                        }
                        set 
                        {
                                if (value == "")
                                        this.fieldSize = null;
                                else
                                        this.fieldSize = fieldSizesDictionary[value].Type; 
                        }
                }
                public NecessityType Necessity
                {
                        get { return this.necessityType; }
                }
                public NecessityTypeData NecessityData
                {
                        get { return necessityTypesDictionary[this.NecessityText]; }
                }
                public string NecessityText
                {
                        get
                        {
                                string result = "";
                                foreach (KeyValuePair<string, NecessityTypeData> necessityTypeItem in necessityTypesDictionary)
                                        if (necessityTypeItem.Value.Type == this.necessityType)
                                        {
                                                result = necessityTypeItem.Value.VisibleName;
                                                break;
                                        }
                                return result;
                        }
                        set { this.necessityType = necessityTypesDictionary[value].Type; }
                }
                public int Order
                {
                        get { return this.order; }
                        set { this.order = value; }
                }
                public bool IsNameField
                {
                        get { return this.isNameField; }
                        set { this.isNameField = value; }
                }
                public bool SystemField
                {
                        get { return this.systemField; }
                        set { this.systemField = value; }
                }
        public bool LockedField
        {
            get { return this.lockedField; }
            set { this.lockedField = value; }
        }

                public bool VisibleOnForms
                {
                        get { return this.visibleOnForms; }
                        set { this.visibleOnForms = value; }
                }
                public bool UniqueValue
                {
                        get { return this.uniqueValue; }
                        set { this.uniqueValue = value; }
                }
                public bool NeedsTranslation
                {
                        get { return this.needsTranslation; }
                        set { this.needsTranslation = value; }
                }
                public bool Multiline
                {
                        get { return this.multiline; }
                        set { this.multiline = value; }
                }

                public bool HighField
                {
                        get { return highField; }
                        set { highField = value; }
                }
                public bool ReadOnly
                {
                        get { return readOnly; }
                        set { readOnly = value; }
                }
                public Table RelatedTable
                {
                        get { return this.relatedTable; }
                        set { this.relatedTable = value; }
                }
                public string ForeignKeyFieldName
                {
            get
            {
                 if (this.RelatedTable == null) return "";
                foreach (var field in Table.Fields.Values)
                {
                    if (field.RelatedTable!=null && field.ID != ID && field.RelatedTable.ID == RelatedTable.ID)
                        return string.Format("FK {0} ID", this.Name);
                }
                return string.Format("FK {0} ID", this.RelatedTable.Name);
               /*return (this.RelatedTable == null)
                     ? ""
                     : string.Format("FK {0} ID"
                         , ((this.Type == FieldType.MultipleLookup)
                                 ? this.RelatedTable.Name
                                 : this.name)); */
            }
                }
                public string QueryName
                {
                        get { return this.queryName; }
                        set { this.queryName = value; }
                }
                public string QueryNameWithoutParameters
                {
                        get 
                        {
                                int breacketIndex = this.queryName.IndexOf('(');

                                if (breacketIndex == -1)
                                        return this.queryName;
                                else
                                        return this.queryName.Substring(0, breacketIndex);
                        }
                }
                public int? ParentFieldID
                {
                        get { return this.parentFieldID; }
                        set { this.parentFieldID = value; }
                }
                public int MaxLength
                {
                        get 
                        {
                                if (this.fieldSize == Field.FieldSize.Small)
                                        return RAIS.Common.Constants.SMALL_FIELD_MAX_LENGTH;
                                else if (this.fieldSize == Field.FieldSize.Medium)
                                        return RAIS.Common.Constants.MEDIUM_FIELD_MAX_LENGTH;
                                else if (this.fieldSize == Field.FieldSize.Large)
                                        return RAIS.Common.Constants.LARGE_FIELD_MAX_LENGTH;
                                else if (this.fieldSize == Field.FieldSize.Memo)
                                        return RAIS.Common.Constants.MEMO_FIELD_MAX_LENGTH;
                                else
                                        return 0;
                        }
                }
                public bool IsLookupField
                {
                        get 
                        {
                                if ((this.fieldType == FieldType.LookupPlusIntegerValue)
                                        || (this.fieldType == FieldType.LookupPlusScientificValue)
                                        || (this.fieldType == FieldType.SingleLookup)
                                        || (this.fieldType == FieldType.MultipleLookup)
                                        )
                                        return true;
                                else
                                        return false;
                        }
                }
                public bool IsTextField
                {
                        get
                        {
                                if (this.fieldType == FieldType.Text)
                                        return true;
                                else
                                        return false;
                        }
                }
                #endregion
                //*********************************************************************
                #region Constructors
                public Field()
                {}

                public Field(IDataRecord record)
                {
                        this.ID = (int)record["PK Field ID"];
                        this.Name = record["Field Name"].ToString();
                        this.localLanguageFieldName = record["Local Language Field Name"].ToString();
                        this.fieldPurpose = record["Field Purpose"].ToString();
                        this.localLanguageFieldPurpose = record["Local Language Field Purpose"].ToString();
                        this.fieldType = (FieldType)Enum.Parse(typeof(FieldType), record["Field Type Name"].ToString());
            if (record["Field Size Name"] is DBNull)
                this.fieldSize = null;
            else
                this.fieldSize = (FieldSize)Enum.Parse(typeof(FieldSize), record["Field Size Name"].ToString());
            this.necessityType = (NecessityType)Enum.Parse(typeof(NecessityType), record["Necessity Type Name"].ToString());
                        this.order = (int)record["Order"];
                        this.isNameField = (bool)record["Is Name Field"];
                        this.systemField = (bool)record["System Field"];
                        this.visibleOnForms = (bool)record["Visible On Forms"];
                        this.uniqueValue = (bool)record["Unique Value"];
                        this.needsTranslation = (bool)record["Needs Translation"];
                        this.multiline = (bool)record["Multiline"];
                        this.highField = (bool)record["High Field"];
                        this.readOnly = (bool)record["Read Only"];
            this.lockedField = (bool)record["Locked"];
                        if (record["PK Table ID"].ToString() != "")
                                this.RelatedTable = new Table(record);
                        this.queryName = record["Field Query Name"].ToString();
                        if (!(record["FK Parent Field ID"] is DBNull))
                                this.parentFieldID = (int)record["FK Parent Field ID"];
                }
                #endregion
                //*********************************************************************
                #region Nested classes
                public class FieldTypeData
                {
                        //*********************************************************************
                        #region Fields
                        int id;
                        string name;
                        string visibleName;
                        #endregion
                        //*********************************************************************
                        #region Properties
                        public int ID
                        {
                                get { return this.id; }
                        }
                        public FieldType Type
                        {
                                get { return (FieldType)Enum.Parse(typeof(FieldType), this.name); }
                        }
                        public string VisibleName
                        {
                                get { return this.visibleName; }
                        }
                        #endregion
                        //*********************************************************************
                        #region Constructors
                        public FieldTypeData()
                        {}
                        public FieldTypeData(IDataRecord record)
                        {
                                this.id = (int)record["PK Field Type ID"];
                                this.name = record["Field Type Name"].ToString();
                                this.visibleName = record["Field Type Visible Name"].ToString();
                        }
                        #endregion
                }

                public class FieldSizeData
                {
                        //*********************************************************************
                        #region Fields
                        int id;
                        string name;
                        string visibleName;
                        FieldType fieldType;
                        #endregion
                        //*********************************************************************
                        #region Properties
                        public int ID
                        {
                                get { return this.id; }
                        }
                        public FieldSize Type
                        {
                                get { return (FieldSize)Enum.Parse(typeof(FieldSize), this.name); }
                        }
                        public string VisibleName
                        {
                                get { return this.visibleName; }
                        }
                        public FieldType FieldType
                        {
                                get { return fieldType; }
                        }
                        #endregion
                        //*********************************************************************
                        #region Constructors
                        public FieldSizeData()
                        {}
                        public FieldSizeData(IDataRecord record)
                        {
                                this.id = (int)record["PK Field Size ID"];
                                this.name = record["Field Size Name"].ToString();
                                this.visibleName = record["Field Size Visible Name"].ToString();
                                this.fieldType = (FieldType)Enum.Parse(typeof(FieldType), record["Field Type Name"].ToString());
                        }
                        #endregion
                }

                public class NecessityTypeData
                {
                        //*********************************************************************
                        #region Fields
                        int id;
                        string name;
                        string visibleName;
                        #endregion
                        //*********************************************************************
                        #region Properties
                        public int ID
                        {
                                get { return this.id; }
                        }
                        public NecessityType Type
                        {
                                get { return (NecessityType)Enum.Parse(typeof(NecessityType), this.name); }
                        }
                        public string VisibleName
                        {
                                get { return this.visibleName; }
                        }
                        #endregion
                        //*********************************************************************
                        #region Constructors
                        public NecessityTypeData()
                        {}
                        public NecessityTypeData(IDataRecord record)
                        {
                                this.id = (int)record["PK Necessity Type ID"];
                                this.name = record["Necessity Type Name"].ToString();
                                this.visibleName = record["Necessity Type Visible Name"].ToString();
                        }
                        #endregion
                }
                #endregion
        }
}